Ganor's Blog

Installing Jenkins Server on Google Cloud Platform

2014-04-07T09:37:00.002-07:00

The goal of this short post is to show how to spin a Jenkins server on Google Cloud Platform.

Create a new instance

This is a simple one. Browse to your Google Cloud console https://console.developers.google.com and create a new instance. Make sure you:

Select a small (or greater) instance type.
Select Debian as your OS.
If you have a network rule that enables TCP 8080 then use it. Otherwise, you can configure this later on to your default rule.

Install Jenkins

To use the Debian package repository of Jenkins, first add the key to your system:

wget -q -O - http://pkg.jenkins-ci.org/debian/jenkins-ci.org.key | sudo apt-key add -

Then add the following entry in your /etc/apt/sources.list:

deb http://pkg.jenkins-ci.org/debian binary/

Update your local package index, then finally install Jenkins:

sudo apt-get update
sudo apt-get install openjdk-7-jre
sudo update-java-alternatives --set java-1.7.0-openjdk-amd64
sudo apt-get install jenkins

Configure the default network rule

In Google Cloud Console go to your project and select Compute Engine | Networks | Firewall rules. Create a new rule. Include tcp:80,8080 to your "Allowed Protocols or Ports"

That's it! Browse to your instance external IP and concatenate :8080.

Building PhoneGap / Apache Cordova iOS Apps with Jenkins

2012-11-27T08:09:00.000-08:00

While there are several posts related to Jenkins and PhoneGap, I couldn't find a complete, up-to-date, 'step by step' guides that show how to setup continuous integration builds for your team.

I wanted to share my experience with both tools, but first let's start with some assumptions and requirements:

As of today the most updated development environment version is XCode 4.5 w/ iOS 6.0. It is highly recommended to update to the latest and greatest version so things work properly.
I used the latest Jenkins which is downloadable from its download site
After installing Jenkins, I used this cool xcode-plugin that really helps to get things done. You can install it by going to Manage Jenkins | Manage Plugins | Available | Search for xcode and install it.
As an optional step you should also install the Amazon S3 plugin to push the "Enterprise Site" artifacts (the IPA and PLIST files) so it can be available to others in your team.
You must have Apple's iOS Developer Program account. Make sure you create a Certificate and Distribution (Adhoc) provisioning profile using the portal. Start by creating a certificate for Distribution (remember to do this through the "Distribution" tab) and continue with adding the devices you want to test with. Finally create a provisioning profile (remember to do this in the "Distribution" tab). If you have done things correctly you should have a certificate in your default keychain. Here is what I see:

(1) Apple's Certificate (2) Your Certificate (3) Your private key
Make sure you have something like this in your user's Keychain
Another assumption is that you use the latest version of Phonegap (currently v2.2) which provides handy command line tools to create iOS application shell. I used:

./path/to/cordova-ios/bin/create /path/to/my_project com.example.my_project

Now before we start the real fun, let's explain a couple of caveats for working with Jenkins in this context:

Jenkins jobs run as the jenkins user (created by the Jenkins installer), your jenkins user doesn't really know about the Keychain that you have created. We will create a different Keychain accessible by your jenkins user.
Same goes to provisioning profiles, we will need to install the distribution provisioning profile for the jenkins user.
Code Signing for development and distribution is done with different provisioning profiles, from time to time, developers override the project settings so the profile (the Xcode UI really sucks!) is configured wrongly. For this end we will add a script that makes sure we use the right profile.

Now let's start the real fun:

Export the user's Keychain (usually under /Users//Library/Keychains) and import it into new Jenkins' Keychain (usually under /Users/Shared/Jenkins/Library/Keychains):
user$ security default-keychain # retrieve the user's default keychain
user$ security export -k <user-keychain> -f pkcs12 -o <output-file-name>
user$ sudo su jenkins # switch to jenkins account
jenkins$ security create-keychain -P <jenkins-keychain>
jenkins$ security import <exported-file-name> -k <jenkins-keychain> -f pkcs12 -A
jenkins$ security default-keychain -s <jenkins-keychain>
Copy your distribution provisioning profile to jenkins' user profiles directory /Users/Shared/Jenkins/Library/MobileDevice/Provisioning Profiles/
Create a Jenkins job using the xcode plugin
Fetch your code from git then add a build step which executes the xcode plugin build

Remember that you should fill in these parameters
- Target
- Configuration
- Project directory
- output directory
- Build IPA
- Provisioning profile - direct to your profile
- Unlock the keychain and provide the Keychain and its password
In your job you will need to make sure that the right profile is used during the execution, I had to use some search and replace tricks. For this end I first find the provisioning profile's hash (a 28 hex-decimal hash):
cp </path/to/.xcodeproj>/project.pbxproj </path/to/.xcodeproj>/project.pbxproj.bak

sed 's/PROVISIONING_PROFILE\ =\ "[^\"]*"/PROVISIONING_PROFILE\ =\ "<Profile Hash>"/g' </path/to/.xcodeproj>/project.pbxproj > </path/to/.xcodeproj>/project.pbxproj.pro1

sed 's/\"PROVISIONING_PROFILE\[sdk=iphoneos\*]\"\ =\ "[^\"]*"/\"PROVISIONING_PROFILE\[sdk=iphoneos\*]\"\ =\ "<Profile Hash>"/g' </path/to/.xcodeproj>/project.pbxproj.pro1 > </path/to/.xcodeproj>/project.pbxproj.pro2

mv </path/to/.xcodeproj>/project.pbxproj.pro2 </path/to/.xcodeproj>/project.pbxproj
Distribute to external enterprise site - this one worth a separate post

REST Sniffer and Client - Working Together

2012-11-19T13:22:00.004-08:00

A month ago I posted about REST Sniffer, a Chrome extension that helps with tracking REST calls. This time, I'll present a cool new feature that can help developers to detect and analyze bugs as well as support common Web apps development process integrated with Advanced REST Client.

The use case is very common, you are a Web (or Mobile-Web) developer given with a bug or scenario that requires several steps to reproduce. You probably start with opening a browser and trying out these steps. After simulating it, open the network panel and investigate that it's an API issue originated from this specific scenario (data, flow, state, etc). Now starts the beautiful twist, you pinpoint this API call and detach it to an external client that can reproduce this call in a similar environment. Let's see how it works in real life:

First you sniff your Web App's APIs, and click the "Load in REST Client" button

This operation automatically detaches this specific API call (including its method, URL, path, parameters and headers) to the Advanced REST Client where you can review and exercise this call again and again. Ultimately, step by step debugging it in your favorite IDE.

Finally Review the results in your client after resolving the issue

Many thanks to Paweł Psztyć the "Advanced REST Client" Google Chrome App creator who worked together with me on the integration and made it possible.

If you want to read more visit this short page prepared to help with understanding the workflow in details.

7 Tips for PhoneGap (&Mobile-Web) Beginners

2012-10-15T10:01:00.000-07:00

While the mobile app market continues to grow steadily, mobile app development knowledge in most companies is still immature. Most companies have already aligned their business strategies with the latest mobile-world changes and started recruiting mobile teams but haven't yet streamlined their app development processes. This problem is notable also among mobile-web app developers, where the two domains have synthesized into one platform that carries both methodologies and twists. Here are some tips and thoughts I've gathered through my work with PhoneGap / Apache Cordova.

It’s a mobile app not a web app
The very first thing you notice when switching from web app to mobile-web app development is that your tools and environment are quite similar. This may lead to a misconception about your target audience environment and behavior. Actually, there is little in common between a web browser user and a mobile app user. For example the .click() event has a major role in browser use but really doesn't fit the mobile context where users prefer to tap (touch) elements of their app interface. Technically, "touchend” events are fired with no delay so they are significantly faster than “click” events.

Another example of a behavior that usually happens in the context of web browsers and doesn't make any sense in mobile apps, is highlighting elements after a user has clicked on them. In a mobile app, you need to prevent objects from being highlighted by a touch event.

Using a fully featured engine/framework vs. your own stack of libraries
As in creating web or desktop apps, one should choose the right UI patterns to develop mobile apps easily. Most mobile app workflows fit into short and gamified scenarios. There are plenty of game engines and App UI frameworks that can be very handy. Rather than using a fully featured framework that may limit your scenarios and put them in the wrong pattern, there is the option of using low-level libraries that solve a specific problem. This is usually better if your game or app has specific UI requirements like special animation but is less recommended if you want to build a traditional mobile-web app. Combining several libraries such as backbone.js and jquery transit may provide a great starting point in creating a flexible interface and smooth workflows.

Responsiveness and image preloading
You may make the assumption that since you are working on a client-side app, there is zero-time resource loading, for example, for loading images, scripts and local data files. This is, of course, not true and may cause bad user experiences and slow response times. To solve it, there are two methods that should be taken:
Use Asynchronous Module Definition (AMD) to load resources and handle dependencies. One simple implementation is requirejs.
Use the sprite technique to store your images and improve the drawing time. One simple implementation is spritejs.

Usage analytics and A/B testing in the context of mobile web
Tracking and analyzing your users’ experience of your app is a key factor for improving your product incrementally. This also enables you to drop the MVP (most valuable product) before releasing a fully featured mobile app. Three great examples that are already adjusted to the mobile app world are Google Analytics, Mixpanel and KISSmetrics. Another technique that should help with improving your product incrementally is AB testing. This allows you to switch the content or view of your mobile app to show how your users consume it. For example, you can reorder the main menu items to see how many people get to the goal of selecting an option that you want them to select (purchasing your app, downloading more content, etc.).

Different platforms, same conventions? customization?
If you target several mobile platforms, it’s a bit naïve to think that your app is going behave in an identical manner on all platforms. This may lead to the fact that you will need to customize your app according to the target platform it is running on. Another factor is that if you use plain Apache Cordova (rather than the Phonegap build) you will need to customize several platform-dependent settings on your own. For example, if you want to hide the status bar when running your app, in iOS you will need to tweak Info.plist with the key field “UIStatusBarHidden” and the value “YES”. In Android it’s done differently by tweaking the app’s manifest file.

Emulator
One of the key benefits to using mobile-web is the fact that you can have one emulator that fits all platforms. In other words, you don’t need a different emulator for each platform (iOS emulator, Android Emulator, etc.). Chrome Ripple extension is the easiest way to do that.

Continuous delivery
A key decision you will need to decide upfront is what method to use to build your mobile app, either independently (in-house) or using the Phonegap build. If you decide the former you can use automatic tools such as Jenkins and XCode Jenkins Plugin, which are highly recommended for easing the delivery process and streamlining the work within your team.

Sniff Your RESTful API

2012-07-30T08:17:00.002-07:00

Over the last couple of weeks I have been working on a project that required full understanding of its RESTful API. During that time I was using traditional tools like my browser and an extra extension that allows me to get acquainted with the app's internal API. The main workflow (as a developer or a tester) was to make an action in the browser and then try to resolve what the hack happened under the hood.

So... I wrote an extension that made my life easier. Basically this extension provides my browser the power being aware of a specific RESTful API that is relevant to Web application.

If you work with backbone.js, angularJS or spine (actually if you work with RESTful Web app) this can be highly valuable as you see the net traffic that is related to the Application.

First the user defines the high level endpoint structure:

Then when your app is monitored this info is presented:

Since it's an open source Github project, feel free to contribute and / or send pull requests.

if-ify, for-ify, foreach-ify and func-ify

2012-02-19T04:02:00.000-08:00

A common question among developers is how to surround the current selection in the editor with a parent statement. For example if you start coding a statement that validates an expression and then want to iterate over an array of expressions and do the same to all its elements.

For this end Eclipse templates provide two variables "line_selection" and "word_selection" that help you build custom selection-based wrappers.

In this example three new templates were added to simplify this scenario:

You can import these templates (xml below) to your IDE via Preferences > PHP > Editor > Templates > Import...

How My Wife Drives the Technology World

2012-02-01T23:36:00.000-08:00

ok, maybe a better name would be "My Cloud-based-Social-enabled-Service-oriented Mobile Apps Experience", but that's a long name for a post :)

It started last week as a small-talk between my wife and me about she attending so many shifts and medical sessions. According to my wife, she usually takes 4-5 shifts a month where the actual number is doubled (!). At that moment I had no tools to prove my point and here comes the requirements to build a small mobile app for her to report shifts and sessions while being able to write short notes about it (ok, she was asking this a long time ago). In addition she usually posts some info on Facebook during her shifts so I had to connect these reports somehow to her Facebook account. By the end of the month she hand a report about her shifts to the managers so this if the app could also print a summary it will be a big value for her.

Before sharing thoughts about my experience with this app development, here is how this app looks like on Android and iOS:

Mobile App
jQueryMobile (version 1.0) is really handy for creating cross-platform mobile interface, it provides easy to use APIs and is really covered well with lots of great examples. I had to use several other libraries like jQueryUrl, Moment.js, Mustache, requireJS and jsPDF. With so many "out-of-the-box" libraries it is super easy to build robust solution for client side in minutes(!!!)

Social-enabled:
Facebook JavaScript SDK helped me with giving a more "social look and feel" after creating a Facebook application. I also used Facebook's OAth service authentication and Open Graph integration so users notify their friends about their activities with the "My Doctor Shifts" application. That's super important to engage the application users to your application!

Service-oriented (and Data-centric)
Zend Framework provides nice (lightweight) models representation and the MVC was useful to create the HTML view and services.

Cloud-based
Using phpCloud was easy as always with plenty of slick workflows helping me to easily deploy my application and push updates to staging and testing targets. This way I always kept two versions that represent my Work in Progress and Done apps. I also got packages ready for deployed in case I want to deploy it to another Zend Application Fabric instance.

The application is available on github.

Getting Started with Facebook App Development

2012-01-19T05:31:00.000-08:00

Last week I was playing with Facebook App development, getting ready to the Facebook announcement. It was quite pleasant experience, although things could be simpler. The Facebook Open Graph concept gives a nice overview on what and why this all about, so that part went very smooth. When things get technical, the Facebook Developers site turns messy. That is, all topics are covered in a 'tutorial' approach rather than an API approach like most developers are used to. Moreover, the layout of this page is definitely not intuitive as it mixes between reference and tutorial docs. That's said, the general experience was good.

To help other developers get started with Facebook app development I created a nice application which take the reader through the steps to develop applications with phpcloud.com. It was a nice exercise and it can really help with the development workflow.

The topic "Getting Started with Your Facebook App on phpcloud.com" covers :

Create an account on phpcloud.com
Create an app on Facebook
Setting up development environment
Deploy a sample Facebook app to phpcloud.com
Push updates to your Facebook app

A (Big) Dot Release

2011-12-14T21:26:00.000-08:00

Although dot releases don't get as much attention as major releases , this one should definitely get highlighted:

      "Zend is pleased to announce the release of Zend Studio 9.0.1!"

This new release focuses on improving source code editing experience, improving editor performance, smart indentation when pasting code. It also extends the code formatter so PHP comments are well structured. Working with PHPUnit made easier with the addition of smart configuration (and bootstrap) detection. Community plugins updates provide advanced features with Git, ZenCoding and Symfony2.

The changes include:

Improved editor performance for multi-line statements and auto indentation scenarios
Adjust indentation when pasting code
New code formatter rules for PHP Comments
Disable/Enable Code formatter with special @formatter:off/on tags
Git history graph
PHPUnit auto-detection of configuration (and bootstrap) file
Improved PHP Class creation for namespace code generation
Easy installation of community plugins ZenCoding and Symfony2 and Twig
Various bug fixes

Rewrite Rulez!!!

2011-12-05T23:43:00.001-08:00

While common Web frameworks provide a set of mod_rewrite rules in their default application, it is left to the developer to align these rules according to the Apache host configuration. For example if you use an alias when setting up a Symfony application then a RewriteBase directive must be added to the application rules. This is a common change that is required to keep the original list (provided by the framework) as is.

To this end a post-deployment action can be added to fix the RewriteBase directive in the '.htaccess' file. In a previous post, application deployment scripts were used to help chmod application's resources. This time I am going to use deployment hooks to modify the RewriteBase directive automatically after deploying the Symfony2Cloud application.

In the deployment script you can find this code:

<?
// get application location
$appLocation = getenv('ZS_APPLICATION_BASE_DIR');
// modify htaccess
$htaccess_file = $appLocation . '/web/.htaccess';
$explode = explode ( '/', $appLocation );
$appname = $explode [sizeof ( $explode ) - 2];
$content = file_get_contents ( $htaccess_file );
$content = str_replace ( '<application-name>', $appname, $content );
file_put_contents ( $htaccess_file, $content );
view raw            post_stage.phpThis Gist brought to you by GitHub.

In details: The application location is used to resolve its alias. Then the alias name is used to replace the .htaccess file content so instead of "RewriteBase /<application-name>

it will show up as "RewriteBase /Symfony2Cloud".

Assuming that you use Zend SDK and the following deploy command:

zend deploy application -r git://github.com/ganoro/Symfony2Cloud.git

Symfony2Cloud is now deployed and ready to use with this .htaccess:

<IfModule mod_rewrite.c>
 RewriteBase /Symfony2Cloud

    RewriteEngine On
    RewriteCond %{REQUEST_FILENAME} !-f
    RewriteRule ^(.*)$ app_dev.php [QSA,L]
</IfModule>

Github to Zend Developer Cloud - the fast way!

2011-11-30T06:24:00.001-08:00

In previous posts I discussed several methods of building Web applications using Zend Developer Cloud and github, mainly with tools like Eclipse and Zend Studio. This time, I will show off with a new feature in Zend SDK v0.0.22 (and up) presented by Wojtek Galanciak.

With this feature only one command line is required to deploy applications from github to Zend Developer Cloud. Here is a simple example:

zend deploy application -r git://github.com/ganoro/Symfony2Cloud.git -t 0

"Symfony2Cloud" repository is hosted in my github account. Target id 0 is my Zend Developer Cloud container. This command makes sure that the applications is deployed into my Zend Developer Cloud container. As simple as that...

Read more about this command and similar use cases with the new Zend SDK. Release notes are available here.

In my next posts I am going to explain about the new repository management tools, so stay tuned.

chmod() your phpCloud Web Apps

2011-11-27T05:04:00.001-08:00

A common feedback from developers using Web Apps on Zend Developer Cloud is the ability to chmod() directories for deployed applications. For example in Joan Ging's post you can notice that one needs to use external tools (like WinSCP or Zend Studio) to chmod the logs and cache directories that are used by Symfony2, otherwise these directories are write-protected and the application fails to launch.

There are two methods to chmod application directories after the deployment stage and before launching.
So let's review the two alternatives, both of them result in the same state:

Using Deployment Scripts (during deployment phases).
Using Zend Studio (after the application is deployed)

Using Deployment Scripts

One of the new features in phpCloud is the ability to deliver hook scripts alongside the application. There are several types of scripts for each phase in the deployment process (i.e, Staging, Activation).
In the following example, chmod is executed on both logs and cache directories immediately after being executed on their parents.
First we define the "scripts" directory to contain all deployment triggers. This is done as part of the deployment descriptor file (named deployment.xml):

<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<package xmlns="http://www.zend.com/server/deployment-descriptor/1.0" version="1.0">
    <name>Symfony2Cloud</name>
    <version>
        <release>1.0.0</release>
    </version>
    <appdir>data</appdir>
    <docroot>data/web</docroot>
    <scriptsdir>scripts</scriptsdir>
</package>
view raw            deployment.xmlThis Gist brought to you by GitHub.

Then we create a post_stage.php file under this directory with this content:

<?php
/* @var string holds the application (absolute) path */
$appLocation = getenv('ZS_APPLICATION_BASE_DIR');
/* chmod cache and logs */
chmod ( $appLocation, 0775 );
chmod ( $appLocation . '/app/',0775 );
chmod  $appLocation . '/app/cache/', 0775 );
chmod ( $appLocation . '/app/logs/', 0775 );
view raw post_stage.php    This Gist brought to you by GitHub.      

The complete source code for this application is available in the Synfony2Cloud project on Github.

Using Zend Studio 9.0

Once you deploy your application in Zend Studio, a connection to your container is created under the hood. You can view this connection and modify the directories permissions in the Remote System view.

1. Start by showing (or "unhiding") hidden files. This allows you to browse the ".app" directory which holds all deployed applications.
Go to Preferences > Remote Systems > Files and make sure "Show hidden files" is marked.

2. Browse to the application you want to chmod() by expanding the file tree in the Remote Systems view

3. Right click on the directory and select Properties.
4. Select the Permissions node, alter the permissions you want to allow and click Apply.

Although Alternative #2 is more flexible, I highly recommend Alternative #1 which streamlines the deployment phase and lets you adjust the code and create an automate deployment process.

What is coming up from Zend?

2011-11-02T08:18:00.000-07:00

If you have already heard about phpcloud.com and Zend Studio 9 or just trying to grasp what new developer workflows Zend is now offering, you may find the new tutorials that the Zend documentation team have put together quite useful. These tutorials take you through end to end real world scenarios and outline what can be achieved with the new tools and platform. These tutorials include:

Building Applications on the Zend Developer Cloud (link)

To create GitHub and Zend Developer Cloud accounts. These will be used to maintain a project in GitHub and to deploy on Zend's cloud platform. Github is just an example, you could use other version control system such as Git, Subversion, CVS, Mercurial.
To create a new container in the Zend Developer Cloud. The container holds your application in the cloud.
To create a new project from GitHub. You will be using an existing GitHub project to create a new project in Zend Studio.
To launch the application on the Zend Developer Cloud and debug it using Zend Studio.

A Guided Tour of Zend Application Deployment Support (link)

To create a new project from GitHub in Zend Studio: You will be provided with an existing GitHub account and project.
To work with your project's deployment.xml file: Launching a project in Zend Studio with deployment support creates a deployment.xml file. This file enables you to customize your application before the packaging process.
To create a ZPK package: Packaging your application enables you to export it to other members of the working process for testing and evaluation.

Deploying Applications to Zend Server (link)

To create an API Key. The API Key allows Zend Studio to access your server.
To create a new PHP project from SVN in Zend Studio. You will be provided with an existing SVN account and project.
To deploy your project on a remote Zend Server.
To launch your application. After creating your application, Zend Studio enables you to run your application from within the IDE and in an internal browser

Running Applications on a Local Zend Server (link)

To create a new Zend Framework project under the local server document root.
To debug your application and modify code.
To launch your application.

Customizing Zend Studio (link)

To customize Zend Studio by adding and removing the plugins you want to work with. The Welcome page includes a list of available plugins, which you can add or remove from your Zend Studio.
To register Zend Studio. Once Zend Studio is installed, all its features will be available for a 30 day trial. To enable full features after this period of time, you will need to register the product.

Eclipse Continues to Support PHP and Zend Developer Cloud

2011-10-27T15:56:00.000-07:00

The last two weeks were a-m-a-z-i-n-g! We released two major pieces that can turn Web development as easy and obvious as writing this hello world application. This time I would like to present additional important piece that the Zend team provide today to enable PHP and Web development (special thanks to @nataliabartol). Welcome the 'Eclipse-based package by Zend'. This package includes the Eclipse Platform latest release (version 3.7.1, code name Indigo-SR1), the Web Tools Source Editing plugin, the PDT plugin (latest version) and the Zend SDK plugin (this plugin enables Zend Developer Cloud). You can find the package and more information about this release here. The size of this package is ~90Mb (depending on your operating system) and users need to extract the package to run the product.

Zend is the provider of Zend Studio 9.0 and lead the Eclipse PHP Development Tools (PDT) project as well as the Zend SDK project. This Eclipse-based product will mainly be useful for developers working with PHP and their workflow includes tasks such as PHP/HTML/Javascript/CSS sources editing, debugging and deployment of Web applications.

The following two minutes demo shows a simple create-deploy-debug cycle enabled by this package:

My team will definitely consider leveraging the Zend SDK to work with more solutions available in the market providing Integrated Development Environment (IDE) for PHP Developers such as Netbeans and phpStorm, stay tuned!

If you have any questions or comments, feel free to comment below.

Pull Down an Application Created on phpCloud

2011-10-25T06:10:00.000-07:00

One of the most promising features in Zend Developer Cloud will be to deploy today's most-famous Web applications directly into your container, without being required to supply the application package. The list of pre-packed applications includes projects like Drupal, Joomla, Magento, Wordpress and a customized Zend Framework. Probably Zend will add more applications in the future (want to suggest one?)

The obvious question is, what will be the best practice for working with an already deployed application and how to pull it down to your development environment?

As a background there are two ways for managing an already deployed project, you can select either of the following options depending on your high level development workflows and your tools (ahch, ahch, Zend Studio supports both of them). One important note that is applied for both solutions - you don't need to deploy the project once again. Just modify the content and make sure it's updated properly in the cloud.

Clone Application via Git Repository

One of the Easter Eggs hidden in this already-packed deployment feature is that once an application is deployed, a git repository is created so developers can clone it and later on push their content. Use a command line tool or any development environment to clone the application. Then use push to upstream git action to update the actual remote application.

To retrieve the application Git Repository, go to you container overview page:
https://my.phpcloud.com/container/<container-name>/overview and push the "git access" button. Use your container name and password as username and password when you make any operation with this repository.

This Git repository authentication is based on secured HTTP with the following details:

URI: the path provided by Zend Developer cloud (see above)
User: container name
Password: container password

Using Zend SDK:

You can use the latest Zend SDK to clone the code to your machine by running the git clone command with your git repository parameters:

zend clone project -r <git-repository-url> -u <user> -p <password>

Using Zend Studio 9.0:
We are about to use a new feature added to Zend Studio in its latest release that enables you to clone a Git repository, start by File | New | PHP Project from Git. A wizard will show up and you will need to enter the information required for this clone operation to happen.

Follow the wizard and hit "Finish". Once your project is cloned, you can start a debug session right-clicking on the index.php file and selecting "Debug as...", supply the full URL of the application and press OK.

Don't forget to open the SSH Tunnel by right-clicking on its node that available in the Targets view and selecting "Open SSH Tunnel"

Download Application via SFTP Client

The trivial way is to use an integrated SFTP client that supports download and upload actions to the SFTP server installed on your container. Remember the following:

Authentication to the SFTP is made using the private key given the time you created the container or user. So you will need to add it to the private keys manager (in Zend Studio / Eclipse it's under Preferences > General > Network Connections > SSH2. In the General Tab, add the private key file to the text field named: "Private Keys". You don't have to specify a username and password as you use the private key.
The application content is located under the directory named .apps/http/__default__/0/<user-name>/1.0.0

Hope this tutorial helps you to configure your development environment and you take advantage of it, but if you think there is a different (better) way don't hesitate to comment below.

Test Drive Zend Developer Cloud with Zend Studio 9

2011-10-22T15:04:00.000-07:00

Zend Studio and the Zend Developer Cloud support an integration environment for projects hosted in GitHub. This allows you use the cloud to deploy, debug and modify your Web applications hosted in GitHub from Zend Studio.

This workflow includes the following tasks:

Creating accounts for GitHub and the Zend Developer Cloud
Developing a project hosted in Github with Zend Studio and the Zend Developer Cloud
Debugging your application
Automatically updating your application in real time

Prerequisites

An installed Zend Studio 9.0 (currently on beta) or above. Can be found in one of these pages:

Zend Studio 9 Beta page
Zend Studio product page

Creating an Account for Github and the Zend Developer Cloud

In order to use GitHub and the Zend Developer Cloud, you must first set up valid accounts for both.
To create a GitHub account:

Open the GitHub website at https://github.com/.
Click Plans, Pricing and Signup in the center of the welcome page. The Plans and Pricing page appears. Click Create a free account. The Signup for GitHub page appears.
Enter your account details in the requested fields, and click Create an account. Your new account page appears.
Follow the instructions on the Github homepage and create a project and repository.
For more information on creating a GitHub project go to help.github.com

To create a Zend Developer Cloud account:

Open the Zend Developer Cloud website at http://www.phpcloud.com/.
Click Login here in the top-right corner of the homepage.
Click I do not have an account. The Create a new account page appears.
Enter your account details in the requested fields, and click Register. The Thank you for creating a Zend account page appears.
Please answer the questions that appear on the page and click Finish. The Log In page appears.
Enter your account details, and click Log In. The Zend Developer Cloud welcome appears.
Click Start now to begin working! Save your Zend Developer Cloud credentials as you will need them later in this workflow.

Working with a Project hosted in Github with Zend Studio and the Zend Developer Cloud

Once you have an existing GitHub and Zend Developer Cloud account, you can use the integration features embedded in Zend Studio and Zend Developer Cloud. You can develop, test and deploy a GitHub application on the cloud through Zend Studio. To create a new container:

Go to the Zend Developer Cloud homepage and open your account and click Start Now on the welcome page. The Create Container page appears.
Enter the container name and password in the relevant fields, and click Create Container. The SSH Keypair created window appears.
Click Download private key in PEM format. Save the key on your machine as you will need to browse to it when connecting Zend Studio to your server. Your container has been created and will appear under My Containers on the homepage.

Installing the GitHub Plugin into Zend Studio

Zend Studio gives you the option to use only the plugins you need. For this tutorial, you will need GitHub.

Go to Help | Welcome to open the Zend Studio Welcome screen.
From the plugin list on the right, mark the Git and GitHub.
When prompted, restart Zend Studio . When you re-open Zend Studio, the GitHub plugin is installed.

Creating a GitHub Project in Zend Studio

To create a GitHub application in Zend Studio:

Go to File | New |PHP Project from GitHub. The Create Project from GitHub dialog appears.
Enter the project name and your GitHub authentication details in the relevant fields, and click Refresh. Your application location will appear in the Location box or in the dropdown menu.
Click Next to move to the Application Deployment dialog.
Select Zend Application Deployment and create a new target by clicking on the PHPCloud icon . The Add Target dialog box appears
Enter your Zend.com credentials and browse to your PEM key in the relevant fields, and click Test Connection.
If no errors appear, click Finish. The Application Deployment section reappears with the target you added.
Make sure the ‘Add Application Deployment Support’ checkbox is marked
Click Finish. Your application will opens in the Zend Studio workspace.

Deploying Your Application on the Zend Developer Cloud

Open your project in Zend Studio. The default file, deployment.xml, opens.

In the Testing area, click Launch a PHP Application The Launch PHP Application dialog opens with the default container you defined during the project creation selected, and your application’s URL
Click Finish and Yes when prompted about your container’s authenticity
Your application appears in your container’s page in the Zend Developer Cloud website, and opens in Zend Studio’s internal browser. Keep the internal browser with your application open as you will need it to automatically update the application.

Debugging Your Application on the Zend Developer Cloud

Open your project in Zend Studio. The default file, deployment.xml, opens.
In the Testing area, click Launch a PHP Application in Debug Mode
Your application now appears in the Debug perspective and stops at the first breakpoint. To continue the debug click .

Automatically Updating Your Deployed Project in Real Time

Zend Studio allows you to automatically update any changes you make in the source code of your application without redeploying the application from the start. Each change you make in the code will be automatically updated in your application on the server.
To automatically update your application:

In the PHP Explorer view, open your projects index.phptml file by going to application| views| scripts | index| index.phptml. The index.phptml file opens in the text editor.
Make a small textual change in the code and save the project.
Go to the internal browser of your project and click the Refresh icon . Your application updates with the changes applied.

Note: this article describes the workflow as available today for phpcloud developers. I am not sure if this will be the case in next versions, so you should get updated with the php cloud release notes. It was written by the documentation team at Zend, if you have any comment feel free to post it below.

First API released for phpcloud.com

2011-10-18T13:00:00.000-07:00

In previous post, I presented the Zend Developer Cloud Platform and some thoughts about it. It's time for me to show some pretty cool API we added for developers who want to exploit all the goodies from it. In a nutshell, the Zend Developer Cloud API enables you to authenticate, list your containers details and get a very nice information about your requests, and of course to start debugging of specific events occurred lately.

The first implementation using this API is the Zend Developer Cloud sniffer that "integrates into the PHP runtime and watches for various events such as errors, failing functions, slow scripts and database errors. This allows you to debug your application during development, helping you create a better application.". And the first implementation of this API is available under EPL at the Zend SDK source code In more details the following API is available:

```
authenticate(u, p, _success, _error)
```
Authenticate to the Zend Developer Cloud service given the username and password. Once authentication is validated, a session id is retrieved and assigned as cookie
```
list(_success, _error)
```
Lists all containers for the signed in user
```
requestSummary(containerName, requestUid, _success, _error)
```
Retrieve information about a particular request's events and code tracing. The requestUid identifier is provided in a cookie that is set in the response to the particular request.
```
downloadAmf(containerName, amf, _success, _error)
```
Download the amf file specified by codetracing identifier

startDebug(containerName, issueId, eventGroupId, _success, _error)

Start a debug session for specific issue

Better Together - Github and Zend Developer Cloud

2011-10-18T09:40:00.000-07:00

The two Cloud-based services Zend Developer Cloud and GitHub share some common traits. Although these services are loosely coupled, developers using one service can easily find interest in the other. For example the openness of the services to application developers world, the (so important) social dimension and the fact that it is just easy to use through a set of APIs and tools, make these two services fun to work with... together.

It takes four command lines to see the value (you will need to install Zend SDK first):

# clone an example 'hello tweet' project from a github repository
$ zend clone project -r git://github.com/zendcon/hellotweet.git

# define a Developer Cloud container to host your application
$ zend add target -d account-name:account-password

# set working directory
$ cd  hellotweet

# deploy the newly created application to the defined target
$ zend deploy application

The result is available as a ready to use Web application http://royganor.my.phpcloud.com/zendcon/ and since I made the container public anyone can create the same container through http://my.phpcloud.com/container/create/snapshot/royganor-snapshot-20111018054539

But there are more similarities, let's review some of them:

Identities are open and visible between developers

Applications and repositories are listed:

Social activities are available for developers who want/need continuous and fast feedback

If you are interested in more information about specific aspect of the solution, share it here and I will answer you.

Zend Launches Developer Cloud & SDK To Give Developers Access to Web Applications Market

2011-10-18T08:43:00.000-07:00

Zend, The PHP company and the place I work for the past 5 years has made some significant steps over the last year to enable Web developers to deliver scalable Web applications. As part of our strategy Zend has been full-steam ahead on creating better ways for Web developers to make application deployed on a self-served container which can be scaled up and down which have been traditionally difficult areas for PHP developers to execute effectively.

In May the Zend Server team has published a major update to the product with the ability to create application packages that consist of source code, metadata and scripts, and of course deploy applications on any number of servers. At about the same time, my team has worked to deliver tools supporting these capabilities.

Today, Zend is adding the remaining piece, again utilizing its current product line. The company today announced that it is releasing the Zend Developer Cloud and a software development kit (SDK) called Zend SDK to enable Web developer build their applications on a robust platform in a very short time. This is of interest for the very reason that this service is given for free by Zend.

When it comes to entering the PHP applications market like Wordpress, Drupal, Magento, Zend Framework apps, developers are met with a number of obstacles, including environment requirements and unstructured development tools. The advantage then, of Zend′s new platform and SDK is that now developers have streamlined workflows to develop their applications.

To demonstrate how easy it is to create Web applications with the new tools, I created a GitHub repository for a #zendcon tweeter channel https://github.com/zendcon/hellotweet and made it available on my container at http://royganor.my.phpcloud.com/zendcon/ in about a couple of minutes.

Stay tune for more posts and information about this news.

Zend Studio 9 Early Access build #262 now available

2011-09-28T07:58:00.000-07:00

In a previous post I demoed how Zend Studio 9 is going to make Web application development much easier and faster. I am pleased to announce that the Early Access (build #262) is now available so early adopters can put their hands on and tell us about their experience with the new product.

Feel free to post your feedback here or in Zend Studio forum.

For Windows (212 Mb)
For Windows without JRE (182Mb)
For Mac (172Mb)
For Linux 32-bit (173Mb)
For Linux 64-bit (176Mb)

Agile Web Applications Development with Eclipse Indigo and Zend Studio 9 Early Access

2011-09-27T08:18:00.000-07:00

It's been a couple of weeks now since the release of Eclipse Indigo and other Application Servers IDEs based on it. Now, it's time for the Eclipse PDT and Zend Studio team to refresh their products with great features that lots of Web developers will find useful such as Github support, Application deployment support, better formatting and source editing tools for PHP and JS developers.

In this short screen cast you will find a quick review of the features available for the developers working with it.

Stay tune and wait for the official release which is going to happen soon.

"git clone" and "application deploy" - Perfect Match

2011-09-14T06:05:00.000-07:00

It's amazing, you work on a pretty cool project for a couple of months now and you find out that little has been posted about it.
So here it is... meet Zend SDK. There are many interesting ideas behind this SDK but in this post I am going to focus on how to get started with it.

So... what is Zend SDK?

If you build a Web Application or even a CMS Web site in PHP you probably have asked yourself a couple of times what best practices should I use to develop, publish and discover applications written in PHP. Amazingly, in most modern platforms like Java, Ruby, Flash, Android and iOS it is common to find a dominant set of tools and workflows to streamline development processes. Things like creating application resources, deploying applications, configuring application hosts and even creating a repository of applications that allows others to discover it. However for several reasons PHP developers don't have one way to do such things, just as an example take a look at the famous PHP applications, frameworks and CMSs solutions in the market. This is exactly where the SDK is aiming.

Zend SDK includes a variety of tools that help you create, develop, publish and discover PHP Web applications.

Hence, you can find command line tool, Eclipse plugin, Hudson/Jenkins, Phing, Ant and other tools in our target environments.

Step 1: Clone your application from a Git repository

First thing first, you will need to fetch the application source code and prepare it for the target environment, to do so you can use the "clone project" command line. With this command a project from a git repository is cloned to your local machine and additional deployment descriptor resource is added that will assist you with hosting this application on targets.

zend clone project -r https://ganoro@github.com/ganoro/ExampleProject.git

Alternatively you can create a local empty project based on the MVC of Zend Framework by clicking

zend create project -n helloworld

If you have already fetched your project (with SVN, CVS or other source control version) you can just update the project with the files required to help you with the deployment process:

zend update project -d

for more information on project management, read this wiki page which goes over the alternatives and provides extra details about the possible arguments of these commands. If you haven't installed the SDK go to this page

Step 2: Add a remote target

This is the easy part, you will need a target that will host your applications. I assume you installed Zend Server 5.5 and it is accessible by your machine. If not, you will need to install it either locally or on a remote machine.

For example adding a remote target with address 10.1.2.34 with a given secret key is possible by

zend add target -h http://10.1.2.34 -k sdk.roy -s cc14b445ad6ed9041d936b7f363a8e5a525275d3960dbb373f35e97e2abcdab2

This command line will add a new target to the list with the specified API key, for more details on API keys see this page. After installing this target you can use the list target and list applications to see the results:

Example output for a listing command is (read more on targets management here):

royganor@ubuntu:~$ zend list targets -s
Available Zend Targets:
id: 0
	Host: https://10.1.2.34
	Key: Zend 	Status: connected

Step 3: Deploy your application

Now that your application is ready and your target is configured properly, we can go directly to the fun part. deploying you application to the host.

royganor@ubuntu:~$ zend deploy application

Step 4: Test it!
Now you are ready to see if the application deployed successfully by running a stats command or just going to the browser and address the application URL.

royganor@ubuntu:~$ zend list applications
Id:                     67
Application Name:       drupal
User Application Name:  http://default-server/ExampleProject
Base URL:               http:///ExampleProject
Installed Location:     /home/royganor/.apps/http/__default__/0/ExampleProject/1.0.0
Status:                 deployed
Servers:
	id:               0
	Deployed Version: 1.0.0
	Status:           deployed
Deployed Versions:	1.0.0

Step 5: What's next?
In next posts more interesting aspects of the SDK will be covered like creating repositories and publishing your applications to others.As usual if you want to. Till next time, I will really appreciate your feedback on Zend SDK

Windows Registry API for Windows (plus 64-bit)

2011-05-21T13:42:00.000-07:00

Lately I was required to provide a solution that needs access to the Windows Registry Keys. I could easily use the command line tools for this end (reg export or something like this). For some reason I found several glitches with this method, mainly around performance and parsing incompatibilities. So I decided to use this library JNIRegistry - "Windows Registry API Native Interface" (http://www.trustice.com/java/jnireg/index.shtml).

Problem is that it is only compatible with 32 bit and if you are under 64 bit Java, it won't be any good for you. So I had to compile this JNIRegistry library for 64bit. I used Visual Studio 2010 with the Microsoft SDKs 7.1 to compile it with x86_64 compiler. It was a damn nice adventure...

So if you get this error message "ICE_JNIRegistry.dll: Can't load IA 32-bit .dll on a AMD 64-bit platform" you should probably use the second one here:

1. ICE_JNIRegistry.dll for 32 bit

2. ICE_JNIRegistry for 64bit

3. The JNIRegistry library jar

Enjoy ;)

EDIT: one thing I found while using this library under 64bit. you will need to add the "WOW6432node" child if you look for a software-type key. See this article from MS http://support.microsoft.com/kb/896459.

Project Planning Thoughts on Flash Builder for PHP 4.5

2011-05-03T00:09:00.000-07:00

Wow! it was a real pleasure to take part in and lead the release of Adobe Flash Builder for PHP product. FBPHP is actually an Eclipse-based product that includes both Flash Builder and Zend Studio components and supports the development process of Web and Mobile applications that require server/client communication. It can be a real time saver for startups and large scale companies as it streamlines the process of designers, interactive designers and server side developers in a joint product by Adobe and Zend.

The following two tutorials provide a great overview of how much this product is useful and fun:

Web Application Development - http://goo.gl/EOw2d
Mobile Application Development - http://goo.gl/fRkDt

I would like to give a quick glance on what was required and achieved during the last 4 months, the team obstacles and some tasks repository analysis.

Project Goals

Provide an integrated solution to speed the development of Flex and PHP applications for the web or for mobile
Lower the barrier to entry for getting set up to use Flash Builder and Zend Studio together via an easy installation process
Streamline the process for creating Flex and PHP projects that are related to one another
Improve the data connectivity workflow for connecting Flex apps to PHP services
Enable developers to debug client-side Flex code and server-side PHP code simultaneously
Meet a tight schedule and integration deadlines for both Adobe Flash Builder and Zend Studio teams.

Quality

Features tested – Installation, Serialization, Flex Web/PHP Applications incl. run/debug, Flex Mobile/PHP Application incl. run/debug, Introspection, Remote PHP Server Support, Zend Studio regression
Platforms tested – Windows 7 32/64 bit , Vista 32/64 bit , Windows XP SP3 , MAC OSX 10.6
PHP Servers tested – Zend Server v5.1, MAMP and XAMP
Browsers tested – Firefox , Internet Explorer , Safari, Chrome
Devices tested – Motorola Droid 2, Samsung Galaxy S

Bug Repository Analysis

Powered by 6 developers and 4 quality engineers this project had an overall of 700 issues in the system including tasks, sub tasks, bugs, features and improvements. We had to go through a triage and privatization process on a daily basis and create a weekly process which enables short DEV2QA cycles. The result (below) shows that we had an intense two months of development and 2 months of quality work until we actually started the release cycle that took about a month. The release cycle gave us the ability to stabilize our product quality and make sure we have no misunderstanding with the integration level with Adobe and with the product managers of the product.

Pre-release Advisory Team

177 registered participants, 10-12 very active forum-posters.
> 400 posts to prerelease forums.
> 25 good quality bugs logged.
Most issues either fixed or had a workaround and a few enhancements suggested for future releases

Takeaways

Write your requirements and invest time in polishing and updating the docs - it's not a waste of time. It can take a month and people can start building the building blocks, but to have the solution ready on time you must have a document that represents what you are going to implement from beginning to the end.
Plan a one month quality term, this will significantly improve your predication to deliver a high-quality product. It will not reduce the stress around release cycle but it will reduce the risk in hitting the final date. During this month, developers are not allowed to contribute code to the project unless there is a specific requirement for that.
Our advisory team was very helpful, it is more than important to be responsive and just listen to what they are saying. You are not smarter than they are.
Create a positive spirit in the team and set goals that makes sense to all people.

Thanks to Adobe Flash Builder teams that was very communicative and helpful and showed us the way when integration failed.

Easter Egg for Zend/PHP Developers

2011-03-13T09:09:00.000-07:00

One among many new interesting Zend Server 5.1 features is an open "RESTful Web API that allows automation of the management and deployment of Zend Server and Zend Server Cluster Manager, and integration with other Zend or 3rd party software". It basically provides an easy way to control your deployment of Web Servers remotely and set it up correctly for your application when you scale up and down. For example one can remotely configure new Web application server, reset or even build a fully functional cluster by utilizing this new open API.

Since most of the configuration and deployment tools these days have a Java-based plugins mechanism (such as Jenkins / Eclipse) I thought it would be cool if there will be a way to extend these tools with some of the new Web API features. I am proud to introduce Zend WebAPI project that is hosted in Google Code. Zend Web API SDK for Java provides a Java API for Zend Server infrastructure services, making it even easier for developers to build applications that tap into the scalable, and reliable Zend Server product.

You can find a getting started page that explains how to work with this library. This tutorial is based on the following steps:
1. Signing up for Zend Web API Services
2. Getting your Zend Web API Security Credentials
3. View Your Zend Web API Security Credentials
4. Using the Zend Web API SDK for Java
5. To run a sample you can use this code:

/**
 * Create the credential object
 */
WebApiCredentials credentials = new BasicCredentials(KEY_NAME, SECRET_KEY);

/**
 * Creates the Web API client object
 */
final WebApiClient webApiClient = new WebApiClient(credentials, HOST);

/**
 * Retrieve system info
 */
SystemInfo systemInfo = webApiClient.getSystemInfo();

/**
 * Print license info from retrieved system info
 */
System.out.println("License order number:" + systemInfo.getLicenseInfo().getOrderNumber());

I am really anxious to see what tools we will built on top of these open API that can make a difference in the world of high availability demand from the market.

Thanks to Shahar Evron (@shevron) who has guided me through the API aspects!

If you find this useful I would be happy to get some feedback and even new contribution!

As an example for utilizing this library I created an Eclipse plugin that is used as a "remote controller" for your Zend Server